﻿using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using RiskMan.DataClass.Models.Level;
using RiskMan.Config;
using TheControllerRisk.Settings;
using RiskMan.DataClass.Models.NotBasModels;
using System.Windows.Media;
using RiskMan.DataClass.AlfaDirectFolder;

namespace RiskMan.Views.Level
{
    class LevelLogik
    {
        private DataClass.Data data;
        private MainWindow mainWindow;
        private Level level;
        private LevelItem lvItem;
        double TTP_Last;
        string Classcode;
        private MediaPlayer player = new MediaPlayer();
        private static int tmp = 1;
        int accuraccy;

        public LevelLogik()
        { }

        public LevelLogik(MainWindow mainWindow, Level level)
        {
            this.mainWindow = mainWindow;
            this.data = mainWindow._dataProvider;
            this.level = level;
        }

        public void Start(LevelItem lvItem)
        {
            this.lvItem = lvItem;
            //цена последней сделки
            TTP_Last = mainWindow._dataProvider.GetLastPrice(lvItem.Instrument);
            Classcode = mainWindow._dataProvider.GetClasscode(lvItem.Instrument);
            accuraccy = mainWindow._dataProvider.GetAccuraccy(lvItem.Instrument);
            lvItem.LastPrice = TTP_Last;
            if (lvItem.TypeLevel == cfg.TrendLevel || lvItem.TypeLevel == cfg.TrendLevelFalse)
            {
                lvItem.trendItem.PriceLevel = Math.Round(new TrendLevel().CalculationLevel(lvItem), accuraccy + 1);
            }
            if (lvItem.TypeLevel == cfg.HorizontalLevel || lvItem.TypeLevel == cfg.HorizontalLevelFalse)
            {
                lvItem.trendItem.PriceLevel = lvItem.trendItem.HorizontalLevel;
            }


            // время работы
            if (new WorkingTimeClass(lvItem.Account).IsWork() == true || (new WorkingTimeClass(Classcode).IsWork() && Properties.Settings.Default.adapter == cfg.adapterAlfa))
            {
                #region Открытие поизции
                //время открытия позиций
                if ((!lvItem.UseTimeOpen) || (lvItem.UseTimeOpen && DateTime.Now > lvItem.TimeStartOpenPoz && DateTime.Now < lvItem.TimeEndOpenPoz))
                    if ((lvItem.TradeList == null || lvItem.TradeList.Count == 0) && lvItem.NumberOfAttempt > lvItem.CurNumberOfAttempt)
                    {
                        if (lvItem.TypeLevel == cfg.HorizontalLevel)
                            OpenOrderNew(lvItem);

                        if (lvItem.TypeLevel == cfg.HorizontalLevelFalse)
                            OpenOrderNewHorizontalLevelFalse(lvItem);

                        if (lvItem.TypeLevel == cfg.TrendLevel)
                            OpenOrderNewTrend(lvItem);

                        if (lvItem.TypeLevel == cfg.TrendLevelFalse)
                            OpenOrderNewTrendFalse(lvItem);

                        if (lvItem.TypeLevel == cfg.DoubleLevel)
                            OpenOrderDoubleLevel(lvItem);
                    }
                #endregion

                if ((lvItem.TradeList == null || lvItem.TradeList.Count == 0))
                    lvItem.CurPosition = 0;


                ////если в трейдлисте уже есть заявки
                if (lvItem.TradeList != null || lvItem.TradeList.Count > 0)
                {
                    GetStatusAndBalance(lvItem);
                    KillOpenOrderforCondidtion(lvItem);



                    //GetStatusAndBalance(lvItem);
                    lvItem.CurPosition = 0;
                    foreach (var item in lvItem.TradeList)
                    {
                        if (item.OpenBalance > 0)
                        {
                            if (lvItem.Operation == cfg.Buy)
                                lvItem.CurPosition = lvItem.CurPosition + item.OpenBalance;
                            else
                                lvItem.CurPosition = lvItem.CurPosition - item.OpenBalance;

                            if (lvItem.SoundOpenPoz == false)
                            {
                                if (!String.IsNullOrEmpty(Properties.Settings.Default.SoundOpenPoz))
                                    PlaySound(Properties.Settings.Default.SoundOpenPoz);
                                lvItem.SoundOpenPoz = true;
                            }
                        }
                    }

                    #region Закрытие позиции в конце дня.

                    if (DateTime.Now > lvItem.TimeClosePoz && lvItem.UseTimeClose)
                    {
                        if (lvItem.CurPosition != 0)
                            ClosePozEndDay();
                        return;
                    }

                    #endregion

                    //Выставление стопй-заявок на закрытие позиций
                    if (lvItem.TradeList.Count > 0)
                    {
                        if (lvItem.CurPosition != 0 && (lvItem.TradeList[0].StopLimitCloseStatusOrder == null || (lvItem.TradeList[0].StopLimitCloseStatusOrder == cfg.Cancel && lvItem.TradeList[0].CloseStatusOrder == cfg.Cancel)))
                            CloseStopOrder(lvItem);
                        if (lvItem.TradeList[0].StopLimitCloseStatusOrder != null)
                        {
                            if (Properties.Settings.Default.adapter == cfg.adapterQuik)
                                GetStatusAndBalanceStopLimit(lvItem);
                            if (Properties.Settings.Default.adapter == cfg.adapterAlfa)
                            {
                                GetStatusAndBalanceStopLimitAlfa(lvItem);
                            }
                        }

                    }

                }

                //обнуление активации перестановки в безубыток при нулевой позиции
                if (lvItem.CurPosition == 0)
                    lvItem.BreakevenActive = false;

                lvItem.PrevLastPrice = TTP_Last;
            }
        }

        /// <summary>
        /// Проигрывание музыки при совершении действия
        /// </summary>
        /// <param name="PathSound"></param>
        private void PlaySound(string PathSound)
        {
            player.Stop();
            player.Open(new Uri(PathSound, UriKind.Relative));
            player.Play();
        }


        /// <summary>
        /// Закрытие позиций в конце дня
        /// </summary>
        public void ClosePozEndDay()
        {
            for (int i = 0; i < lvItem.TradeList.Count; i++)
            {
                if (lvItem.SettingOrderOpenClose.TypeStop == cfg.LinkedOrder)
                {
                    if (lvItem.TimeKillStopOrder.TimeOfDay + new TimeSpan(0, 0, 10) <= DateTime.Now.TimeOfDay)
                    {
                        if (lvItem.TradeList[0].StopLimitCloseStatusOrder != null)
                        {
                            if (Properties.Settings.Default.adapter == cfg.adapterQuik)
                                GetStatusAndBalanceStopLimit(lvItem);
                            if (Properties.Settings.Default.adapter == cfg.adapterAlfa)
                            {
                                GetStatusAndBalanceStopLimitAlfa(lvItem);
                            }


                            if (Properties.Settings.Default.adapter == cfg.adapterQuik)
                            {
                                mainWindow.Terminals.CancelStopOrder(lvItem.TradeList[i].StopLimitCloseNumberOrder, lvItem.Instrument, Classcode, lvItem.Account,
                                    lvItem.ClientCode);
                                lvItem.TimeKillStopOrder = DateTime.Now;
                            }
                            if (Properties.Settings.Default.adapter == cfg.adapterAlfa)
                            {
                                mainWindow._dataProvider.TransactionAlfaDirect.DropOrder(lvItem.TradeList[i].StopLimitCloseNumberOrder);
                                lvItem.TimeKillStopOrder = DateTime.Now;
                            }
                        }
                    }
                }

                if (lvItem.TradeList[i].StopLimitCloseStatusOrder == null)
                {
                    AddOrderCloseToTradeList(lvItem.TradeList[i]);
                }
            }


        }

        /// <summary>
        /// выставляем заявку на закрытие позиции
        /// </summary>
        private void AddOrderCloseToTradeList(TradesOpen trade)
        {
            trade.CloseDate = DateTime.Now;
            if (Properties.Settings.Default.adapter == cfg.adapterAlfa)
                trade.CloseID = sendLimitOrderToTerminal(lvItem, trade.OpenQuantity > 0 ? 'S' : 'B', trade.OpenQuantity > 0 ? TTP_Last - lvItem.SettingOrderOpenClose.OtstupForOpenOrder : TTP_Last + lvItem.SettingOrderOpenClose.OtstupForOpenOrder);

            if (Properties.Settings.Default.adapter == cfg.adapterQuik)
            {
                if (Classcode != "SPBFUT")
                    trade.CloseID = mainWindow.Terminals.SendMMMarketID(lvItem.Account, lvItem.ClientCode, trade.OpenQuantity > 0 ? 'S' : 'B',
                    Math.Abs(trade.OpenQuantity), lvItem.Instrument, Classcode, "");
                else
                    trade.CloseID = mainWindow.Terminals.SendOrder(lvItem.Account, lvItem.ClientCode, trade.OpenQuantity > 0 ? 'S' : 'B',
                        data.GetMaxMinPrice(lvItem.Instrument, trade.OpenQuantity > 0 ? 'S' : 'B'),
                        Math.Abs(trade.OpenQuantity), lvItem.Instrument, Classcode);
            }


            trade.CloseQuantity = Math.Abs(trade.OpenQuantity);
            trade.CloseStatusOrder = cfg.Unknown;
        }

        /// <summary>
        /// Выставляем заявку на отрткрытие позиции при горизонтальном уровне
        /// </summary>
        /// <param name="Item"></param>
        private void OpenOrderNew(LevelItem Item)
        {

            if (Item.TradeList == null)
                Item.TradeList = new System.Collections.ObjectModel.ObservableCollection<TradesOpen>();

            if (Item.Operation == cfg.Buy && Item.PrevLastPrice != 0)
                if (Item.PrevLastPrice <= Item.trendItem.HorizontalLevel + Item.Excess && TTP_Last > Item.trendItem.HorizontalLevel + Item.Excess)
                {
                    AddOrderOpenTotradeList(Item, Classcode, Math.Round(Item.trendItem.HorizontalLevel + Item.Excess + Item.SettingOrderOpenClose.OtstupForOpenOrder), Item.Operation == "Купля" ? 'B' : 'S');
                }

            if (Item.Operation == cfg.Sell && Item.PrevLastPrice != 0)
                if (Item.PrevLastPrice >= Item.trendItem.HorizontalLevel - Item.Excess && TTP_Last < Item.trendItem.HorizontalLevel + Item.Excess)
                {
                    AddOrderOpenTotradeList(Item, Classcode, Math.Round(Item.trendItem.HorizontalLevel - Item.Excess - Item.SettingOrderOpenClose.OtstupForOpenOrder), Item.Operation == "Купля" ? 'B' : 'S');
                }
        }

        /// <summary>
        /// Выставляем заявку на отрткрытие позиции при горизонтальном уровне
        /// </summary>
        /// <param name="Item"></param>
        private void OpenOrderNewTrend(LevelItem Item)
        {

            if (Item.TradeList == null)
                Item.TradeList = new System.Collections.ObjectModel.ObservableCollection<TradesOpen>();

            if (Item.Operation == cfg.Buy && Item.PrevLastPrice != 0)
                if (Item.PrevLastPrice <= Item.trendItem.PriceLevel + Item.Excess && TTP_Last > Item.trendItem.PriceLevel + Item.Excess)
                {
                    Item.trendItem.CurTrendPrice = Item.trendItem.PriceLevel;
                    AddOrderOpenTotradeList(Item, Classcode, Math.Round(Item.trendItem.CurTrendPrice + Item.Excess + Item.SettingOrderOpenClose.OtstupForOpenOrder), Item.Operation == "Купля" ? 'B' : 'S');

                }

            if (Item.Operation == cfg.Sell && Item.PrevLastPrice != 0)
                if (Item.PrevLastPrice >= Item.trendItem.PriceLevel - Item.Excess && TTP_Last < Item.trendItem.PriceLevel + Item.Excess)
                {
                    Item.trendItem.CurTrendPrice = Item.trendItem.PriceLevel;
                    AddOrderOpenTotradeList(Item, Classcode, Math.Round(Item.trendItem.CurTrendPrice - Item.Excess - Item.SettingOrderOpenClose.OtstupForOpenOrder), Item.Operation == "Купля" ? 'B' : 'S');
                }
        }

        /// <summary>
        /// Выставляем заявку на отрткрытие позиции при горизонтальном уровне с ложным пробоем
        /// </summary>
        /// <param name="ldItem"></param>
        private void OpenOrderNewHorizontalLevelFalse(LevelItem Item)
        {
            if (Item.TradeList == null)
                Item.TradeList = new System.Collections.ObjectModel.ObservableCollection<TradesOpen>();

            if (Item.Operation == cfg.Buy && Item.PrevLastPrice != 0)
            {
                if (Item.PrevLastPrice >= Item.trendItem.HorizontalLevel && TTP_Last < Item.trendItem.HorizontalLevel)
                {
                    Item.trendItem.FlagProboiLevel = true;
                    Item.trendItem.FlagTimePeroid = DateTime.Now;
                }
                //проверка времени находждения и пройденного расстояния
                if (Item.trendItem.FlagProboiLevel == true)
                {
                    if (Item.trendItem.HorizontalLevel - Item.trendItem.MinProkol >= TTP_Last)
                    {
                        Item.trendItem.FlagDiapazonLevel = true;
                        Item.Comment = "Цена пришла в зону минильного прокола. Робот ждет возвращения цены к роботу";
                    }
                    if (Item.trendItem.FlagTimePeroid.TimeOfDay + TimeConvertor(Item.trendItem.TimeFalseProboi) <= DateTime.Now.TimeOfDay)
                    {
                        Item.trendItem.FlagDiapazonLevel = false;
                        Item.trendItem.FlagProboiLevel = false;
                        Item.Comment = "Нахождение за уровнем больше положенного времени. Работа по уровню прекращена";
                    }
                    if (Item.trendItem.HorizontalLevel - Item.trendItem.MaxProkol > TTP_Last)
                    {
                        Item.trendItem.FlagDiapazonLevel = false;
                        Item.trendItem.FlagProboiLevel = false;
                        Item.Comment = "Цена ушла дальше максимального прокола. Работа по уровню прекращена";
                    }

                    //Вход в позицию
                    if (Item.trendItem.FlagDiapazonLevel = true && Item.PrevLastPrice < Item.trendItem.HorizontalLevel && TTP_Last >= Item.trendItem.HorizontalLevel)
                    {
                        Item.Comment = "Выставлена заявка на открытие позиции";
                        AddOrderOpenTotradeList(Item, Classcode, Math.Round(Item.trendItem.HorizontalLevel + Item.SettingOrderOpenClose.OtstupForOpenOrder), Item.Operation == "Купля" ? 'B' : 'S');
                    }
                }
            }

            if (Item.Operation == cfg.Sell && Item.PrevLastPrice != 0)
            {
                if (Item.PrevLastPrice <= Item.trendItem.HorizontalLevel && TTP_Last > Item.trendItem.HorizontalLevel)
                {
                    Item.trendItem.FlagProboiLevel = true;
                    Item.trendItem.FlagTimePeroid = DateTime.Now;
                }
                //проверка времени находждения и пройденного расстояния
                if (Item.trendItem.FlagProboiLevel == true)
                {
                    if (Item.trendItem.HorizontalLevel + Item.trendItem.MinProkol <= TTP_Last)
                    {
                        Item.trendItem.FlagDiapazonLevel = true;
                        Item.Comment = "Цена пришла в зону минильного прокола. Робот ждет возвращения цены к роботу";
                    }
                    if (Item.trendItem.FlagTimePeroid.TimeOfDay + TimeConvertor(Item.trendItem.TimeFalseProboi) <= DateTime.Now.TimeOfDay)
                    {
                        Item.trendItem.FlagDiapazonLevel = false;
                        Item.trendItem.FlagProboiLevel = false;
                        Item.Comment = "Нахождение за уровнем больше положенного времени. Работа по уровню прекращена";
                    }
                    if (Item.trendItem.HorizontalLevel + Item.trendItem.MaxProkol < TTP_Last)
                    {
                        Item.trendItem.FlagDiapazonLevel = false;
                        Item.trendItem.FlagProboiLevel = false;
                        Item.Comment = "Цена ушла дальше максимального прокола. Работа по уровню прекращена";
                    }

                    if (Item.trendItem.FlagDiapazonLevel = true && Item.PrevLastPrice > Item.trendItem.HorizontalLevel && TTP_Last <= Item.trendItem.HorizontalLevel)
                    {
                        Item.Comment = "Выставлена заявка на открытие позиции";
                        AddOrderOpenTotradeList(Item, Classcode, Math.Round(Item.trendItem.HorizontalLevel - Item.SettingOrderOpenClose.OtstupForOpenOrder), Item.Operation == "Купля" ? 'B' : 'S');
                    }
                }
            }
        }

        /// <summary>
        /// Выставляем заявку на отрткрытие позиции при тренде с ложным пробоем
        /// </summary>
        /// <param name="ldItem"></param>
        private void OpenOrderNewTrendFalse(LevelItem Item)
        {
            if (Item.TradeList == null)
                Item.TradeList = new System.Collections.ObjectModel.ObservableCollection<TradesOpen>();

            if (Item.Operation == cfg.Buy && Item.PrevLastPrice != 0)
            {
                if (Item.PrevLastPrice >= Item.trendItem.PriceLevel && TTP_Last < Item.trendItem.PriceLevel)
                {
                    Item.trendItem.FlagProboiLevel = true;
                    Item.trendItem.FlagTimePeroid = DateTime.Now;
                }
                //проверка времени находждения и пройденного расстояния
                if (Item.trendItem.FlagProboiLevel == true)
                {
                    if (Item.trendItem.PriceLevel - Item.trendItem.MinProkol >= TTP_Last)
                    {
                        Item.trendItem.FlagDiapazonLevel = true;
                        Item.Comment = "Цена пришла в зону минильного прокола. Робот ждет возвращения цены к роботу";
                    }
                    if (Item.trendItem.FlagTimePeroid.TimeOfDay + TimeConvertor(Item.trendItem.TimeFalseProboi) <= DateTime.Now.TimeOfDay)
                    {
                        Item.trendItem.FlagDiapazonLevel = false;
                        Item.trendItem.FlagProboiLevel = false;
                        Item.Comment = "Нахождение за уровнем больше положенного времени. Работа по уровню прекращена";
                    }
                    if (Item.trendItem.PriceLevel - Item.trendItem.MaxProkol > TTP_Last)
                    {
                        Item.trendItem.FlagDiapazonLevel = false;
                        Item.trendItem.FlagProboiLevel = false;
                        Item.Comment = "Цена ушла дальше максимального прокола. Работа по уровню прекращена";
                    }

                    //Вход в позицию
                    if (Item.trendItem.FlagDiapazonLevel = true && Item.PrevLastPrice < Item.trendItem.PriceLevel && TTP_Last >= Item.trendItem.PriceLevel)
                    {
                        Item.trendItem.CurTrendPrice = Item.trendItem.PriceLevel;
                        Item.Comment = "Выставлена заявка на открытие позиции";
                        AddOrderOpenTotradeList(Item, Classcode, Math.Round(Item.trendItem.CurTrendPrice + Item.SettingOrderOpenClose.OtstupForOpenOrder), Item.Operation == "Купля" ? 'B' : 'S');
                    }
                }
            }

            if (Item.Operation == cfg.Sell && Item.PrevLastPrice != 0)
            {
                if (Item.PrevLastPrice <= Item.trendItem.PriceLevel && TTP_Last > Item.trendItem.PriceLevel)
                {
                    Item.trendItem.FlagProboiLevel = true;
                    Item.trendItem.FlagTimePeroid = DateTime.Now;
                }
                //проверка времени находждения и пройденного расстояния
                if (Item.trendItem.FlagProboiLevel == true)
                {
                    if (Item.trendItem.PriceLevel + Item.trendItem.MinProkol <= TTP_Last)
                    {
                        Item.trendItem.FlagDiapazonLevel = true;
                        Item.Comment = "Цена пришла в зону минильного прокола. Робот ждет возвращения цены к роботу";
                    }
                    if (Item.trendItem.FlagTimePeroid.TimeOfDay + TimeConvertor(Item.trendItem.TimeFalseProboi) <= DateTime.Now.TimeOfDay)
                    {
                        Item.trendItem.FlagDiapazonLevel = false;
                        Item.trendItem.FlagProboiLevel = false;
                        Item.Comment = "Нахождение за уровнем больше положенного времени. Работа по уровню прекращена";
                    }
                    if (Item.trendItem.PriceLevel + Item.trendItem.MaxProkol < TTP_Last)
                    {
                        Item.trendItem.FlagDiapazonLevel = false;
                        Item.trendItem.FlagProboiLevel = false;
                        Item.Comment = "Цена ушла дальше максимального прокола. Работа по уровню прекращена";
                    }

                    if (Item.trendItem.FlagDiapazonLevel = true && Item.PrevLastPrice > Item.trendItem.PriceLevel && TTP_Last <= Item.trendItem.PriceLevel)
                    {
                        Item.trendItem.CurTrendPrice = Item.trendItem.PriceLevel;
                        Item.Comment = "Выставлена заявка на открытие позиции";
                        AddOrderOpenTotradeList(Item, Classcode, Math.Round(Item.trendItem.CurTrendPrice - Item.SettingOrderOpenClose.OtstupForOpenOrder), Item.Operation == "Купля" ? 'B' : 'S');
                    }
                }
            }
        }

        /// <summary>
        /// Функция расчет количества контрактов в зависимости от вида расчета
        /// </summary>
        /// <returns></returns>
        public int GetQuantityOpen()
        {
            if (!lvItem.QuantityFromDeposit)
                return lvItem.Quantity;

            if (lvItem.QuantityFromDeposit)
            {
                return (int)data.GetBalance(lvItem.Account, lvItem.ClientCode) / 100 * lvItem.Quantity /
                       data.GetLots(lvItem.Instrument);

            }

            return 0;
        }

        /// <summary>
        /// Обработки логики двойного уровня
        /// </summary>
        /// <param name="item"></param>
        private void OpenOrderDoubleLevel(LevelItem Item)
        {
            if (Item.TradeList == null)
                Item.TradeList = new System.Collections.ObjectModel.ObservableCollection<TradesOpen>();

            if (Item.PrevLastPrice != 0)
                if (Item.PrevLastPrice <= Item.trendItem.UpLevel + Item.Excess && TTP_Last > Item.trendItem.UpLevel)
                {
                    AddOrderOpenTotradeList(Item, Classcode, Math.Round(Item.trendItem.HorizontalLevel + Item.SettingOrderOpenClose.OtstupForOpenOrder), 'B');
                }

            if (Item.PrevLastPrice != 0)
                if (Item.PrevLastPrice >= Item.trendItem.DownLevel - Item.Excess && TTP_Last < Item.trendItem.DownLevel)
                {
                    AddOrderOpenTotradeList(Item, Classcode, Math.Round(Item.trendItem.HorizontalLevel - Item.SettingOrderOpenClose.OtstupForOpenOrder), 'S');
                }

        }

        /// <summary>
        /// Выставление стоп-заявок на закрытие позиции
        /// </summary>
        /// <param name="lvItem"></param>
        private void CloseStopOrder(LevelItem lvItem)
        {
            //находимся в лонге
            double PriceFilled = 0;
            double PriceProfit = 0;
            double StopPrice = GetStopPrice(lvItem, ref PriceFilled, ref PriceProfit);

            if (lvItem.SettingOrderOpenClose.TypeStop == cfg.LinkedOrder)
            {
                if (Properties.Settings.Default.adapter == cfg.adapterQuik)
                    lvItem.TradeList[0].StopLimitCloseID = mainWindow.Terminals.SendLinkedStop(lvItem.Operation == "Купля" ? 'S' : 'B', lvItem.Account, Classcode, lvItem.Instrument, lvItem.ClientCode,
                        Math.Abs(lvItem.CurPosition), StopPrice, PriceFilled, PriceProfit);
                if (Properties.Settings.Default.adapter == cfg.adapterAlfa)
                    lvItem.TradeList[0].StopLimitCloseID = mainWindow._dataProvider.TransactionAlfaDirect.StopLimit(lvItem.ClientCode, Classcode,
                        lvItem.Instrument, (lvItem.Operation == "Купля" ? 'S' : 'B').ToString(), Math.Abs(lvItem.CurPosition), StopPrice, lvItem.SettingOrderOpenClose.StopLimitSpred, PriceProfit);


                if (lvItem.Operation == "Купля")
                {
                    lvItem.TradeList[0].StopLimitCloseOperation = cfg.Sell;
                    lvItem.TradeList[0].StopLimitClosePrice = StopPrice;
                }
                else
                {
                    lvItem.TradeList[0].StopLimitCloseOperation = cfg.Buy;
                    lvItem.TradeList[0].StopLimitClosePrice = StopPrice;
                }

                lvItem.TimeKillStopOrder = DateTime.Now;
                lvItem.TradeList[0].StopLimitCloseQuantity = lvItem.CurPosition;
                lvItem.TradeList[0].StopLimitCloseStatusOrder = cfg.Unknown;
                lvItem.TradeList[0].StopLimitCloseDate = DateTime.Now;

            }
        }

        /// <summary>
        /// Проверяем нужно ли переносить стоп в безубыток
        /// </summary>
        /// <param name="lvitem"></param>
        /// <returns></returns>
        private void RemoveStopBreakeven(LevelItem lvitem, double price)
        {

            if (lvitem.Breakeven != 0 && !lvitem.BreakevenActive)
            {
                if (lvitem.CurPosition > 0)
                    if (TTP_Last >= price + lvitem.Breakeven)
                        lvitem.BreakevenActive = true;
                if (lvitem.CurPosition < 0)
                    if (TTP_Last <= price - lvitem.Breakeven)
                        lvitem.BreakevenActive = true;
            }


        }

        /// <summary>
        /// Рассчитваем цену активации в зависимости от выбарнного типа расчета
        /// </summary>
        /// <param name="lvitem"></param>
        /// <returns></returns>
        private double GetStopPrice(LevelItem lvitem, ref double priceFilled, ref double priceProfit)
        {
            double result = 0;

            if (lvitem.SettingOrderOpenClose.TypePricing == cfg.TypeCloseOrderAuto)
            {
                if (lvitem.CurPosition > 0)
                {
                    #region Горизонтальный уровень
                    if (lvitem.TypeLevel == cfg.HorizontalLevel)
                    {
                        RemoveStopBreakeven(lvitem, lvitem.trendItem.HorizontalLevel);

                        if (!lvitem.BreakevenActive)
                        {
                            result = lvitem.trendItem.HorizontalLevel + lvitem.Excess - lvitem.SettingOrderOpenClose.StopLimitOtstup;
                            priceProfit = lvitem.trendItem.HorizontalLevel + lvitem.Excess + lvitem.SettingOrderOpenClose.Profit;
                        }
                        else
                        {
                            result = lvitem.trendItem.HorizontalLevel + lvitem.BreakevenOtstup;
                            priceProfit = lvitem.trendItem.HorizontalLevel + lvitem.Excess + lvitem.SettingOrderOpenClose.Profit;
                        }
                    }
                    if (lvitem.TypeLevel == cfg.HorizontalLevelFalse)
                    {
                        RemoveStopBreakeven(lvitem, lvitem.trendItem.HorizontalLevel);

                        if (!lvitem.BreakevenActive)
                        {
                            result = lvitem.trendItem.HorizontalLevel - lvitem.SettingOrderOpenClose.StopLimitOtstup;
                            priceProfit = lvitem.trendItem.HorizontalLevel + lvitem.SettingOrderOpenClose.Profit;
                        }
                        else
                        {
                            result = lvitem.trendItem.HorizontalLevel + lvitem.BreakevenOtstup;
                            priceProfit = lvitem.trendItem.HorizontalLevel + lvitem.SettingOrderOpenClose.Profit;
                        }
                    }
                    #endregion

                    #region Трендовый уровень
                    if (lvitem.TypeLevel == cfg.TrendLevel)
                    {
                        RemoveStopBreakeven(lvitem, lvitem.trendItem.CurTrendPrice);

                        if (!lvitem.BreakevenActive)
                        {
                            result = lvitem.trendItem.CurTrendPrice + lvitem.Excess - lvitem.SettingOrderOpenClose.StopLimitOtstup;
                            priceProfit = lvitem.trendItem.CurTrendPrice + lvitem.Excess + lvitem.SettingOrderOpenClose.Profit;
                        }
                        else
                        {
                            result = lvitem.trendItem.CurTrendPrice + lvitem.BreakevenOtstup;
                            priceProfit = lvitem.trendItem.CurTrendPrice + lvitem.Excess + lvitem.SettingOrderOpenClose.Profit;
                        }
                    }
                    if (lvitem.TypeLevel == cfg.TrendLevelFalse)
                    {
                        RemoveStopBreakeven(lvitem, lvitem.trendItem.CurTrendPrice);

                        if (!lvitem.BreakevenActive)
                        {
                            result = lvitem.trendItem.CurTrendPrice - lvitem.SettingOrderOpenClose.StopLimitOtstup;
                            priceProfit = lvitem.trendItem.CurTrendPrice + lvitem.SettingOrderOpenClose.Profit;
                        }
                        else
                        {
                            result = lvitem.trendItem.CurTrendPrice + lvitem.BreakevenOtstup;
                            priceProfit = lvitem.trendItem.CurTrendPrice + lvitem.SettingOrderOpenClose.Profit;
                        }
                    }
                    #endregion

                    if (lvitem.TypeLevel == cfg.DoubleLevel)
                    {
                        RemoveStopBreakeven(lvitem, lvitem.trendItem.UpLevel);

                        if (!lvitem.BreakevenActive)
                        {
                            result = lvitem.trendItem.UpLevel - lvitem.SettingOrderOpenClose.StopLimitOtstup;
                            priceProfit = lvitem.trendItem.UpLevel + lvitem.SettingOrderOpenClose.Profit;
                        }
                        else
                        {
                            result = lvitem.trendItem.UpLevel + lvitem.BreakevenOtstup;
                            priceProfit = lvitem.trendItem.UpLevel + lvitem.SettingOrderOpenClose.Profit;
                        }
                    }

                    priceFilled = result - lvitem.SettingOrderOpenClose.StopLimitSpred;
                }
                if (lvitem.CurPosition < 0)
                {
                    #region Горизонтальный уровень
                    if (lvitem.TypeLevel == cfg.HorizontalLevel)
                    {
                        RemoveStopBreakeven(lvitem, lvitem.trendItem.HorizontalLevel);

                        if (!lvitem.BreakevenActive)
                        {
                            result = lvitem.trendItem.HorizontalLevel - lvitem.Excess + lvitem.SettingOrderOpenClose.StopLimitOtstup;
                            priceProfit = lvitem.trendItem.HorizontalLevel - lvitem.Excess - lvitem.SettingOrderOpenClose.Profit;
                        }
                        else
                        {
                            result = lvitem.trendItem.HorizontalLevel - lvitem.BreakevenOtstup;
                            priceProfit = lvitem.trendItem.HorizontalLevel - lvitem.Excess - lvitem.SettingOrderOpenClose.Profit;
                        }
                    }
                    if (lvitem.TypeLevel == cfg.HorizontalLevelFalse)
                    {
                        RemoveStopBreakeven(lvitem, lvitem.trendItem.HorizontalLevel);

                        if (!lvitem.BreakevenActive)
                        {
                            result = lvitem.trendItem.HorizontalLevel + lvitem.SettingOrderOpenClose.StopLimitOtstup;
                            priceProfit = lvitem.trendItem.HorizontalLevel - lvitem.SettingOrderOpenClose.Profit;
                        }
                        else
                        {
                            result = lvitem.trendItem.HorizontalLevel - lvitem.BreakevenOtstup;
                            priceProfit = lvitem.trendItem.HorizontalLevel - lvitem.SettingOrderOpenClose.Profit;
                        }
                    }
                    #endregion

                    #region Трендовый уровень
                    if (lvitem.TypeLevel == cfg.TrendLevel)
                    {
                        RemoveStopBreakeven(lvitem, lvitem.trendItem.CurTrendPrice);

                        if (!lvitem.BreakevenActive)
                        {
                            result = lvitem.trendItem.CurTrendPrice - lvitem.Excess + lvitem.SettingOrderOpenClose.StopLimitOtstup;
                            priceProfit = lvitem.trendItem.CurTrendPrice - lvitem.Excess - lvitem.SettingOrderOpenClose.Profit;
                        }
                        else
                        {
                            result = lvitem.trendItem.CurTrendPrice - lvitem.BreakevenOtstup;
                            priceProfit = lvitem.trendItem.CurTrendPrice - lvitem.Excess - lvitem.SettingOrderOpenClose.Profit;
                        }
                    }
                    if (lvitem.TypeLevel == cfg.TrendLevelFalse)
                    {
                        RemoveStopBreakeven(lvitem, lvitem.trendItem.CurTrendPrice);

                        if (!lvitem.BreakevenActive)
                        {
                            result = lvitem.trendItem.CurTrendPrice + lvitem.SettingOrderOpenClose.StopLimitOtstup;
                            priceProfit = lvitem.trendItem.CurTrendPrice - lvitem.SettingOrderOpenClose.Profit;
                        }
                        else
                        {
                            result = lvitem.trendItem.CurTrendPrice - lvitem.BreakevenOtstup;
                            priceProfit = lvitem.trendItem.CurTrendPrice - lvitem.SettingOrderOpenClose.Profit;
                        }
                    }
                    #endregion

                    if (lvitem.TypeLevel == cfg.DoubleLevel)
                    {
                        RemoveStopBreakeven(lvitem, lvitem.trendItem.DownLevel);

                        if (!lvitem.BreakevenActive)
                        {
                            result = lvitem.trendItem.DownLevel + lvitem.SettingOrderOpenClose.StopLimitOtstup;
                            priceProfit = lvitem.trendItem.DownLevel - lvitem.SettingOrderOpenClose.Profit;
                        }
                        else
                        {
                            result = lvitem.trendItem.DownLevel - lvitem.BreakevenOtstup;
                            priceProfit = lvitem.trendItem.DownLevel - lvitem.SettingOrderOpenClose.Profit;
                        }
                    }



                    priceFilled = result + lvitem.SettingOrderOpenClose.StopLimitSpred;
                }
            }
            else
            {
                result = lvitem.SettingOrderOpenClose.StopLimitOtstup;
                priceFilled = lvitem.SettingOrderOpenClose.StopLimitSpred;
                priceProfit = lvitem.SettingOrderOpenClose.Profit;
            }

            return result;
        }

        /// <summary>
        /// Отправка транзакций в зависимости от терминала
        /// </summary>
        /// <param name="ldItem"></param>
        /// <param name="oper"></param>
        /// <param name="PriceOpen"></param>
        /// <returns></returns>
        public long sendLimitOrderToTerminal(LevelItem ldItem, char oper, double PriceOpen)
        {
            long ID = 0;

            if (Properties.Settings.Default.adapter == cfg.adapterQuik)
                ID = mainWindow.Terminals.SendOrder(ldItem.Account, ldItem.ClientCode, oper,
                        PriceOpen, ldItem.Quantity, ldItem.Instrument, Classcode);

            if (Properties.Settings.Default.adapter == cfg.adapterAlfa)
                ID = mainWindow._dataProvider.TransactionAlfaDirect.LimitOrder(ldItem.ClientCode, Classcode, ldItem.Instrument, oper.ToString(),
                    ldItem.Quantity, PriceOpen);

            return ID;
        }

        /// <summary>
        /// выставляем заявкку на откртыие позиции и записываем в лист
        /// </summary>
        /// <param name="ldItem"></param>
        /// <param name="Classcode"></param>
        /// <param name="PriceOpen"></param>
        /// <param name="oper"></param>
        private void AddOrderOpenTotradeList(LevelItem ldItem, string Classcode, double PriceOpen, char oper)
        {
            TradesOpen tradesOpen = new TradesOpen();
            tradesOpen.OpenDate = DateTime.Now;
            if (ldItem.SettingOrderOpenClose.TypeOrderOpen == cfg.openOrderLimit)
                tradesOpen.OpenID = sendLimitOrderToTerminal(ldItem, oper, PriceOpen);
            else
            {
                if (Classcode != "SPBFUT")
                    tradesOpen.OpenID = mainWindow.Terminals.SendMMMarketID(ldItem.Account, ldItem.ClientCode, oper,
                    ldItem.Quantity, ldItem.Instrument, Classcode, "");
                else
                    tradesOpen.OpenID = mainWindow.Terminals.SendOrder(ldItem.Account, ldItem.ClientCode, oper,
                        data.GetMaxMinPrice(ldItem.Instrument, oper),
                        ldItem.Quantity, ldItem.Instrument, Classcode);
            }
            if (oper == 'B')
            {
                tradesOpen.OpenOperation = "Купля";
                tradesOpen.OpenPriceOrder = PriceOpen - ldItem.SettingOrderOpenClose.OtstupForOpenOrder;
            }
            else
            {
                tradesOpen.OpenOperation = "Продажа";
                tradesOpen.OpenPriceOrder = PriceOpen + ldItem.SettingOrderOpenClose.OtstupForOpenOrder;
            }

            tradesOpen.OpenQuantity = ldItem.Quantity;
            tradesOpen.OpenStatusOrder = cfg.Unknown;

            if (ldItem.TradeList == null)
                ldItem.TradeList = new ObservableCollection<TradesOpen>();
            ldItem.TradeList.Add(tradesOpen);
            ldItem.CurNumberOfAttempt += 1;

            if (!String.IsNullOrEmpty(Properties.Settings.Default.SoundOrder))
                PlaySound(Properties.Settings.Default.SoundOrder);
            ldItem.SoundOrder = true;
            ldItem.SoundClosePoz = false;
            ldItem.SoundOpenPoz = false;

        }

        /// <summary>
        /// блок проверки заявок на изменение статуса и баланса
        /// </summary>
        /// <param name="ld"></param>
        public void GetStatusAndBalance(LevelItem ld)
        {
            try
            {
                var orderMassiv = data.GetOrderListAll(ld.Account, ld.ClientCode);

                for (int i = 0; i < ld.TradeList.Count; i++)
                {
                    //На открытие поизции по альфа директа, получение номера и присвоение ID, в коллекцию заявок.
                    if (Properties.Settings.Default.adapter == cfg.adapterAlfa)
                    {
                        string tmpOrderalfa = mainWindow._dataProvider.AD.GetLocalDBData("orders", "ord_no, status, b_s, price, qty, rest, ts_time, place_code, p_code, acc_code, stop_price, blank, ord_type, acc_name, comments, stop_price", "comments=" + ld.TradeList[i].OpenID.ToString());
                        if (tmpOrderalfa != null)
                        {
                            Orders order = data.GetLocalDBDataOrdersAlfa(tmpOrderalfa);
                            foreach (var item in data.OrdersAlfa)
                            {
                                if (item.OrdNo == order.OrdNo)
                                {
                                    item.Comments = ld.TradeList[i].OpenID.ToString();
                                    item.Rest = order.Rest;
                                }
                            }
                        }
                    }

                    if (ld.TradeList.Count == 0)
                        break;

                    #region Проверка объема
                    foreach (var item2 in orderMassiv)
                    {
                        //проверка статусов на изменение заявок на открытие пока балансе не равен выставленному числу
                        if (item2.TID == ld.TradeList[i].OpenID && ld.TradeList[i].OpenBalance != ld.TradeList[i].OpenQuantity)
                        {
                            ld.TradeList[i].OpenNumberOrder = item2.Number;
                            ld.TradeList[i].OpenStatusOrder = item2.Status;
                            if (ld.TradeList[i].OpenQuantity == item2.Count)
                                ld.TradeList[i].OpenBalance = item2.Count - item2.OstCount;
                            else
                            {
                                //если заявка снята либо в конце сеесии либо врунчую и надо выставляться на меньший объем
                                if (ld.TradeList[i].OpenQuantity > ld.TradeList[i].OpenBalance + item2.OstCount)
                                    ld.TradeList[i].OpenBalance = ld.TradeList[i].OpenQuantity - item2.OstCount;
                                if (ld.TradeList[i].OpenQuantity == ld.TradeList[i].OpenBalance + item2.OstCount && item2.OstCount == 0)
                                    ld.TradeList[i].OpenBalance = ld.TradeList[i].OpenQuantity;
                            }
                        }

                        //проверка статусов на изменение заявок на закрытие позиции пока балансе не равен выставленному числу
                        if (ld.TradeList[i].OpenBalance == ld.TradeList[i].OpenQuantity)
                            if (item2.TID == ld.TradeList[i].CloseID && ld.TradeList[i].CloseBalance != ld.TradeList[i].CloseQuantity)
                            {
                                ld.TradeList[i].CloseNumberOrder = item2.Number;
                                ld.TradeList[i].CloseStatusOrder = item2.Status;
                                if (ld.TradeList[i].CloseQuantity == item2.Count)
                                    ld.TradeList[i].CloseBalance = item2.Count - item2.OstCount;
                                else
                                {
                                    //если заявка снята либо в конце сеесии либо врунчую и надо выставляться на меньший объем
                                    if (ld.TradeList[i].CloseQuantity > ld.TradeList[i].CloseBalance + item2.OstCount)
                                        ld.TradeList[i].CloseBalance = ld.TradeList[i].CloseQuantity - item2.OstCount;
                                    if (ld.TradeList[i].CloseQuantity == ld.TradeList[i].CloseBalance + item2.OstCount && item2.OstCount == 0)
                                        ld.TradeList[i].CloseBalance = ld.TradeList[i].CloseQuantity;
                                }
                            }
                    }
                    #endregion


                    //если в течении 10 секунд заявка не появилась в системе удалить ее, или ее сняли в ручном формате и не было исполнения, или удаляетс из списка если заявка не определена и уже ее смотрят в другом дне. На закрытие позиции
                    if ((ld.TradeList[i].CloseDate.TimeOfDay + new TimeSpan(0, 0, 30) <= DateTime.Now.TimeOfDay && ld.TradeList[i].CloseStatusOrder == cfg.Unknown)
                        || (ld.TradeList[i].CloseDate.Date != DateTime.Now.Date && (ld.TradeList[i].CloseStatusOrder == cfg.Unknown)))
                    {
                        ld.TradeList.Remove(ld.TradeList[i]);
                        if (i > 0)
                            i--;
                        if (i == 0)
                            break;
                    }

                    //если при переходе в другой день, заявки на закрытие остались активными, то сбросить их в статус null
                    if (ld.TradeList[i].CloseDate.Date != DateTime.Now.Date && ld.TradeList[i].CloseStatusOrder == cfg.Active)
                        ld.TradeList[i].CloseStatusOrder = null;

                    //если в течении 10 секунд заявка не появилась в системе удалить ее, или ее сняли в ручном формате и не было исполнения, или удаляетс из списка если заявка не определена и уже ее смотрят в другом дне
                    if ((ld.TradeList[i].OpenDate.TimeOfDay + new TimeSpan(0, 0, 30) <= DateTime.Now.TimeOfDay && ld.TradeList[i].OpenStatusOrder == cfg.Unknown)
                        || (ld.TradeList[i].OpenStatusOrder == cfg.Cancel && ld.TradeList[i].OpenBalance == 0)
                        || (ld.TradeList[i].OpenDate.Date != DateTime.Now.Date && (ld.TradeList[i].OpenStatusOrder == cfg.Unknown || ld.TradeList[i].OpenStatusOrder == cfg.Active))
                        )
                    {
                        if (ld.TradeList[i].OpenBalance == 0)
                        {
                            ld.TradeList.Remove(ld.TradeList[i]);
                            if (i > 0)
                                i--;
                            if (i == 0)
                                break;
                        }
                        else
                        {
                            ld.TradeList[i].OpenStatusOrder = null;
                        }
                    }

                    if (ld.TradeList[i].OpenStatusOrder == cfg.Cancel && ld.TradeList[i].OpenBalance != 0)
                    {
                        ld.TradeList[i].OpenStatusOrder = null;
                    }

                    //Заявка на открытие и закрытие исполнились полностью
                    if (ld.TradeList[i].CloseStatusOrder == cfg.Performed && ld.TradeList[i].OpenQuantity == ld.TradeList[i].OpenBalance &&
                        ld.TradeList[i].CloseStatusOrder == cfg.Performed && ld.TradeList[i].CloseQuantity == ld.TradeList[i].CloseBalance)
                    {
                        ld.TradeList.Remove(ld.TradeList[i]);
                        if (i > 0)
                            i--;
                        if (i == 0)
                            break;
                    }


                }
            }
            catch
            { }
        }

        public void GetStatusAndBalanceStopLimitAlfa(LevelItem ld)
        {


            #region Проверка по цене для стопа часть 1 из 3

            double PriceFilled = 0;
            double PriceProfit = 0;
            double StopPrice = GetStopPrice(ld, ref PriceFilled, ref PriceProfit);
            List<Orders> order = new List<Orders>();
            #endregion

            try
            {
                var StopLimitMassiv = data.GetStopOrderList(ld.Account, ld.ClientCode);

                for (int i = 0; i < ld.TradeList.Count; i++)
                {
                    //На открытие поизции по альфа директа, получение номера и присвоение ID, в коллекцию заявок.
                    if (Properties.Settings.Default.adapter == cfg.adapterAlfa)
                    {
                        string tmpOrderalfa = mainWindow._dataProvider.AD.GetLocalDBData("orders",
                            "ord_no, status, b_s, price, qty, rest, ts_time, place_code, p_code, acc_code, stop_price, blank, ord_type, acc_name, comments, stop_price",
                            "comments=" + ld.TradeList[i].StopLimitCloseID.ToString());
                        order = data.GetLocalDBDataOrdersAlfaArray(tmpOrderalfa);
                        foreach (var item in data.OrdersAlfa)
                        {
                            for (int j = 0; j < order.Count; j++)
                            {

                                if (order.Count == 1)
                                    if (item.OrdNo == order[0].OrdNo)
                                    {
                                        item.Comments = ld.TradeList[i].StopLimitCloseID.ToString();
                                        item.Rest = order[0].Rest;
                                        item.StopPrice = order[0].StopPrice;
                                        item.Status = order[0].Status;

                                        if (item.Status == cfg.Active)
                                            ld.TradeList[i].OrderFromStopLimitCloseStatusOrder = cfg.Unknown;
                                    }
                                if (order.Count == 2)
                                    if (item.OrdNo == order[j].OrdNo && item.StopPrice == 0 &&
                                        item.Price ==
                                        (ld.TradeList[i].StopLimitClosePrice +
                                         (ld.Operation == "Купля"
                                             ? -ld.SettingOrderOpenClose.StopLimitSpred
                                             : ld.SettingOrderOpenClose.StopLimitSpred)))
                                    {
                                        item.Comments = ld.TradeList[i].StopLimitCloseID.ToString();
                                        item.Rest = order[j].Rest;
                                        ld.TradeList[i].OrderFromStopLimitCloseID = ld.TradeList[i].StopLimitCloseID;
                                        ld.TradeList[i].OrderFromStopLimitCloseNumberOrder = order[j].OrdNo;
                                        ld.TradeList[i].OrderFromStopLimitCloseStatusOrder = order[j].Status;
                                    }
                            }
                        }
                    }

                    if (ld.TradeList.Count == 0)
                        break;


                    #region Проверка по цене для стопа часть 2 из 3

                    foreach (var item2 in StopLimitMassiv)
                    {
                        //заходим в данный блок до активации стоп-заявки
                        if (order.Count == 1)
                        {
                            //проверка статусов на изменение заявок на открытие пока балансе не равен выставленному числу
                            if (item2.TID == ld.TradeList[i].StopLimitCloseID)
                            {
                                ld.TradeList[i].StopLimitCloseNumberOrder = item2.Number;
                                //в случае ручного снятия стопа или при переносе через клиринг
                                if (ld.TradeList[i].StopLimitCloseStatusOrder == cfg.Active &&
                                    item2.Status == cfg.Cancel)
                                    ld.TradeList[i].StopLimitCloseDate = DateTime.Now;
                                ld.TradeList[i].StopLimitCloseStatusOrder = item2.Status;
                                ld.TradeList[i].StopLimitCloseBalance = item2.Count;
                            }
                            if (item2.TID == ld.TradeList[i].StopLimitCloseID)
                            {
                                if (ld.TradeList[i].StopLimitCloseStatusOrder != cfg.Unknown ||
                                    String.IsNullOrEmpty(ld.TradeList[i].StopLimitCloseResult))
                                    ld.TradeList[i].StopLimitCloseResult = item2.Result;
                            }

                            if (item2.TID == ld.TradeList[i].StopLimitCloseID &&
                                ld.TradeList[i].StopLimitCloseStatusOrder == cfg.Active)
                            {
                                //Проверка по цене активации
                                if (ld.TimeKillStopOrder.TimeOfDay + new TimeSpan(0, 0, 10) <= DateTime.Now.TimeOfDay)
                                {
                                    if (item2.StopPrice != StopPrice && item2.StopPrice != 0)
                                    {
                                        mainWindow._dataProvider.TransactionAlfaDirect.DropOrder(item2.Number);
                                        ld.TimeKillStopOrder = DateTime.Now;
                                        ld.TradeList[i].OrderFromStopLimitCloseStatusOrder = null;
                                    }
                                }
                            }
                        }
                    }


                    //если в течении 10 секунд стоп-заявка не появилась в системе удалить ее, или ее сняли в ручном формате и не было исполнения, или удаляетс из списка если заявка не определена и уже ее смотрят в другом дне. На закрытие позиции
                    if ((ld.TradeList[i].StopLimitCloseDate.TimeOfDay + new TimeSpan(0, 0, 30) <= DateTime.Now.TimeOfDay && ld.TradeList[i].StopLimitCloseStatusOrder == cfg.Cancel) && order.Count == 1)
                    {
                        ld.TradeList[i].StopLimitCloseStatusOrder = null;
                    }

                    //обнуление статуса стоп-заявки при снятии стоп-заявки при проверке по цене
                    if (ld.TradeList[i].StopLimitCloseStatusOrder == cfg.Cancel && ld.TradeList[i].OrderFromStopLimitCloseStatusOrder == null)
                    {
                        ld.TradeList[i].StopLimitCloseStatusOrder = null;
                    }

                    #endregion


                    if (ld.TradeList[i].OrderFromStopLimitCloseStatusOrder == cfg.Performed || ld.TradeList[i].StopLimitCloseStatusOrder == cfg.Performed)
                    {
                        ld.BreakevenActive = false;
                        ld.TradeList.Remove(ld.TradeList[i]);
                        if (i > 0)
                            i--;
                        if (i == 0)
                            break;
                    }
                }
            }
            catch
            {
            }

        }

        /// <summary>
        /// блок проверки стоп-заявок статуса и баланса
        /// </summary>
        /// <param name="ld"></param>
        public void GetStatusAndBalanceStopLimit(LevelItem ld)
        {
            try
            {
                var orderMassiv = data.GetOrderListAll(ld.Account, ld.ClientCode);
                var StopLimitMassiv = data.GetStopOrderList(ld.Account, ld.ClientCode);


                #region Проверка по цене для стопа часть 1 из 3

                double PriceFilled = 0;
                double PriceProfit = 0;
                double StopPrice = GetStopPrice(ld, ref PriceFilled, ref PriceProfit);

                #endregion


                //Проверка исполнения заявки типа связанная заявка
                if (ld.SettingOrderOpenClose.TypeStop == cfg.LinkedOrder)
                    for (int i = 0; i < ld.TradeList.Count; i++)
                    {
                        if (ld.TradeList.Count == 0)
                            break;

                        #region стоп лимит
                        foreach (var item2 in StopLimitMassiv)
                        {
                            //проверка статусов на изменение заявок на открытие пока балансе не равен выставленному числу
                            if (item2.TID == ld.TradeList[i].StopLimitCloseID && ld.TradeList[i].StopLimitCloseStatusOrder != cfg.Cancel && ld.TradeList[i].StopLimitCloseStatusOrder != cfg.Performed)
                            {
                                ld.TradeList[i].StopLimitCloseNumberOrder = item2.Number;
                                ld.TradeList[i].StopLimitCloseStatusOrder = item2.Status;
                            }
                            if (item2.TID == ld.TradeList[i].StopLimitCloseID)
                            {
                                if (ld.TradeList[i].StopLimitCloseStatusOrder != cfg.Unknown || String.IsNullOrEmpty(ld.TradeList[i].StopLimitCloseResult))
                                    ld.TradeList[i].StopLimitCloseResult = item2.Result;
                                //если стоп-заявка отвергнута системой выставляем еще раз
                                if (ld.TradeList[i].StopLimitCloseResult == cfg.RemoveFormTs)
                                    ld.TradeList[i].StopLimitCloseStatusOrder = null;
                                //определяем номер заявки выставленной в систему при активации стоп-заявки
                                if (ld.TradeList[i].StopLimitCloseResult == cfg.AddToTs)
                                    ld.TradeList[i].StopLimitCloseNumberLinkidOrder = item2.NumberOrder;
                            }

                            #region Проверка по цене для стопа часть 2 из 3

                            if (item2.TID == ld.TradeList[i].StopLimitCloseID && ld.TradeList[i].StopLimitCloseStatusOrder == cfg.Active)
                            {
                                //Проверка по цене активации
                                if (ld.TimeKillStopOrder.TimeOfDay + new TimeSpan(0, 0, 10) <= DateTime.Now.TimeOfDay)
                                {
                                    if (item2.StopPrice != StopPrice)
                                    {
                                        mainWindow.Terminals.CancelStopOrder(item2.Number, ld.Instrument, Classcode, ld.Account, ld.ClientCode);
                                        ld.TimeKillStopOrder = DateTime.Now;
                                    }
                                }
                            }


                            #endregion

                        }

                        //по прошествии 10 или уже другая дата секунд стоп-заявку можно снять снова, если не получилось с первого раза
                        if ((ld.TimeKillStopOrder.TimeOfDay + new TimeSpan(0, 0, 30) <= DateTime.Now.TimeOfDay || ld.TimeKillStopOrder.Date != DateTime.Now.Date) && ld.TimeKillStopOrder != new DateTime())
                        {
                            ld.TimeKillStopOrder = new DateTime();
                        }

                        //если в течении 10 секунд стоп-заявка не появилась в системе удалить ее, или ее сняли в ручном формате и не было исполнения, или удаляетс из списка если заявка не определена и уже ее смотрят в другом дне. На закрытие позиции
                        if ((ld.TradeList[i].StopLimitCloseDate.TimeOfDay + new TimeSpan(0, 0, 30) <= DateTime.Now.TimeOfDay && ld.TradeList[i].StopLimitCloseStatusOrder == cfg.Unknown)
                            || (ld.TradeList[i].StopLimitCloseDate.Date != DateTime.Now.Date && (ld.TradeList[i].StopLimitCloseStatusOrder == cfg.Unknown)))
                        {
                            ld.TradeList[i].StopLimitCloseStatusOrder = null;
                        }
                        #endregion


                        //провереям заявки на выставление
                        if (ld.TradeList[i].StopLimitCloseStatusOrder != null && ld.TradeList[i].StopLimitCloseStatusOrder != cfg.Unknown)
                        {
                            foreach (var item2 in orderMassiv)
                            {
                                //проверка статусов на изменение заявок на закрытие позиции
                                if (ld.TradeList[i].StopLimitCloseID == item2.TID && ld.TradeList[i].CloseStatusOrder == null)
                                {
                                    ld.TradeList[i].CloseStatusOrder = item2.Status;
                                    ld.TradeList[i].CloseNumberOrder = item2.Number;
                                    ld.TradeList[i].CloseID = item2.TID;
                                }

                                if (ld.TradeList[i].CloseStatusOrder != null && ld.TradeList[i].CloseID == item2.TID && ld.TradeList[i].StopLimitCloseNumberLinkidOrder == 0)
                                    ld.TradeList[i].CloseStatusOrder = item2.Status;

                                //удаляем трейдлист, если происходит исполнение заявки на профит
                                if (ld.TradeList[i].CloseStatusOrder == cfg.Performed)
                                {
                                    ld.TradeList.Remove(ld.TradeList[i]);
                                    if (i > 0)
                                        i--;
                                    if (i == 0)
                                        break;
                                }

                                if (ld.TradeList[i].StopLimitCloseResult == cfg.AddToTs)
                                {
                                    if (ld.TradeList[i].StopLimitCloseNumberLinkidOrder == item2.Number && ld.TradeList[i].OrderFromStopLimitCloseStatusOrder == null)
                                    {
                                        ld.TradeList[i].OrderFromStopLimitCloseStatusOrder = item2.Status;
                                        ld.TradeList[i].OrderFromStopLimitCloseNumberOrder = item2.Number;
                                        ld.TradeList[i].OrderFromStopLimitCloseID = item2.TID;
                                    }

                                    if (ld.TradeList[i].OrderFromStopLimitCloseStatusOrder != null && ld.TradeList[i].OrderFromStopLimitCloseID == item2.TID && ld.TradeList[i].StopLimitCloseNumberLinkidOrder == item2.Number)
                                        ld.TradeList[i].OrderFromStopLimitCloseStatusOrder = item2.Status;

                                    //если заявка снята (возможно ручками) исполнена в полном объеме
                                    if (ld.TradeList[i].OrderFromStopLimitCloseStatusOrder == cfg.Performed)
                                    {
                                        ld.TradeList.Remove(ld.TradeList[i]);
                                        if (i > 0)
                                            i--;
                                        if (i == 0)
                                            break;
                                    }
                                    //если заявка снята (возможно ручками) или во время клиринга
                                    if (ld.TradeList[i].OrderFromStopLimitCloseStatusOrder == cfg.Cancel)
                                    {
                                        ld.TradeList[i].StopLimitCloseStatusOrder = null;
                                        ld.TradeList[i].CloseStatusOrder = null;
                                        ld.TradeList[i].OrderFromStopLimitCloseStatusOrder = null;
                                    }
                                }
                            }
                        }

                    }
            }
            catch
            { }
        }


        //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!Доделать этоже для альфы при запуске проекта в продажу!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        /// <summary>
        /// Очистка листа. Если заявка на октрытие не исполнилась по заданным уловиям (отклонение цены от уровня больше заданного, время неисполнения больше заданного)
        /// </summary>
        /// <param name="ld"></param>
        private void KillOpenOrderforCondidtion(LevelItem ld)
        {
            //
            for (int i = 0; i < ld.TradeList.Count; i++)
            {
                if (ld.SettingOrderOpenClose.KillOrderOpen != cfg.Unknown && ld.TradeList[i].OpenStatusOrder != cfg.Unknown && ld.TradeList[i].OpenBalance == 0)
                {
                    if (ld.SettingOrderOpenClose.KillOrderOpen == cfg.KillofTime || ld.SettingOrderOpenClose.KillOrderOpen == cfg.KillOfTimeOrDistance)
                        if (ld.TradeList[i].OpenDate.TimeOfDay + TimeConvertor(ld.SettingOrderOpenClose.TimeWiatOpenPoz) <= DateTime.Now.TimeOfDay)
                        {
                            mainWindow.Terminals.CancelOrder(ld.TradeList[i].OpenNumberOrder, ld.Instrument, Classcode, ld.Account, ld.ClientCode);
                            ld.TradeList.Remove(ld.TradeList[i]);
                            if (i > 0)
                                i--;
                            if (i == 0)
                                break;
                        }

                    if (ld.SettingOrderOpenClose.KillOrderOpen == cfg.KillOfDictance || ld.SettingOrderOpenClose.KillOrderOpen == cfg.KillOfTimeOrDistance)
                    {
                        if (ld.Operation == cfg.Buy && ld.trendItem.HorizontalLevel + ld.Excess + ld.SettingOrderOpenClose.SpredForKillOrderOpen <= TTP_Last)
                        {
                            mainWindow.Terminals.CancelOrder(ld.TradeList[i].OpenNumberOrder, ld.Instrument, Classcode, ld.Account, ld.ClientCode);
                            ld.TradeList.Remove(ld.TradeList[i]);
                            if (i > 0)
                                i--;
                            if (i == 0)
                                break;
                        }
                        if (ld.Operation == cfg.Sell && ld.trendItem.HorizontalLevel - ld.Excess - ld.SettingOrderOpenClose.SpredForKillOrderOpen >= TTP_Last)
                        {
                            mainWindow.Terminals.CancelOrder(ld.TradeList[i].OpenNumberOrder, ld.Instrument, Classcode, ld.Account, ld.ClientCode);
                            ld.TradeList.Remove(ld.TradeList[i]);
                            if (i > 0)
                                i--;
                            if (i == 0)
                                break;
                        }

                    }
                }
            }
        }


        private TimeSpan TimeConvertor(int seconds)
        {
            int hour = seconds / 60 / 60;
            int minutes = (seconds - 60 * 60 * hour) / 60;
            int second = seconds - 60 * 60 * hour - minutes * 60;
            TimeSpan result = new TimeSpan(hour, minutes, second);

            return result;
        }
    }

    /// <summary>
    /// Расчет ифнормации по свечам для тренда
    /// </summary>
    internal class TrendLevel
    {
        /// <summary>
        /// Расчет цены текущего тренда
        /// </summary>
        /// <param name="lvItem"></param>
        /// <returns></returns>
        public double CalculationLevel(LevelItem lvItem)
        {
            if (lvItem.TypeLevel == cfg.TrendLevel || lvItem.TypeLevel == cfg.TrendLevelFalse)
            {
                int countCandle = 0;
                string classcode = MainWindow.StaticLevel._dataProvider.GetClasscode(lvItem.Instrument);
                if (lvItem.trendItem.Interval != cfg.day && lvItem.trendItem.Interval != cfg.week &&
                    lvItem.trendItem.Interval != cfg.month)

                #region Работа с интервалами до дня

                {
                    TimeSpan interval = GeTimeSpan(lvItem);
                    TimeSpan tmpTime = lvItem.trendItem.DateTimeSecondCandle.TimeOfDay;
                    foreach (var item in MainWindow.StaticLevel._dataProvider.CalendarItemList)
                    {
                        if (Convert.ToDateTime(item.DateOfYear).Date >=
                            Convert.ToDateTime(lvItem.trendItem.DateTimeSecondCandle).Date
                            &&
                            Convert.ToDateTime(item.DateOfYear).Date <=
                            DateTime.Now.Date
                            )
                        {
                            if (Convert.ToDateTime(item.DateOfYear).Date !=
                                Convert.ToDateTime(lvItem.trendItem.DateTimeSecondCandle).Date &&
                                Convert.ToDateTime(item.DateOfYear).Date >
                                Convert.ToDateTime(lvItem.trendItem.DateTimeSecondCandle).Date)
                            {
                                if (classcode == "SPBFUT")
                                    tmpTime = GettamplateTime(item.ShablonTime).StartTimeForts;
                                else
                                    tmpTime = GettamplateTime(item.ShablonTime).StartTimeMmvb;
                            }


                            for (int i = 0; i < 10000; i++)
                            {
                                //добавление интервалов в день и время последней точки
                                if (Convert.ToDateTime(item.DateOfYear).Date ==
                                    DateTime.Today)
                                    if (tmpTime + interval < DateTime.Now.TimeOfDay)
                                    {
                                        tmpTime = tmpTime + interval;
                                        countCandle++;
                                    }
                                    else
                                    {
                                        break;
                                    }
                                if (Convert.ToDateTime(item.DateOfYear).Date !=
                                    DateTime.Today)
                                {
                                    var tmpTamlate = GettamplateTime(item.ShablonTime);
                                    if (classcode == "SPBFUT")
                                    {

                                        //Обработка клирингов
                                        if (tmpTime + interval <= tmpTamlate.EndTimeForts &&
                                            tmpTime + interval > tmpTamlate.StartTimeForts)
                                        {
                                            if (tmpTime + interval <= tmpTamlate.StartDayKliring ||
                                                (tmpTime + interval >= tmpTamlate.EndDayKliring &&
                                                 tmpTime <= tmpTamlate.StartEveningKliring) ||
                                                tmpTime + interval > tmpTamlate.EndEveningKliring)
                                            {
                                                countCandle++;
                                                tmpTime = tmpTime + interval;
                                            }
                                            else
                                            {
                                                tmpTime = tmpTime + interval;
                                            }
                                        }

                                    }
                                    if (classcode != "SPBFUT")
                                        if (tmpTime <= tmpTamlate.EndTimeMmvb &&
                                            tmpTime + interval > tmpTamlate.StartTimeMmvb)
                                        {
                                            countCandle++;
                                            tmpTime = tmpTime + interval;
                                        }
                                        else
                                        {
                                            break;
                                        }
                                }

                            }
                            if (Convert.ToDateTime(item.DateOfYear).Date == DateTime.Today)
                                break;

                        }
                    }
                }
                #endregion

                else
                {

                    DateTime tmpTime = lvItem.trendItem.DateTimeSecondCandle;
                    foreach (var item in MainWindow.StaticLevel._dataProvider.CalendarItemList)
                    {
                        var tmpTamlate = GettamplateTime(item.ShablonTime);
                        if (Convert.ToDateTime(item.DateOfYear).Date >=
                            Convert.ToDateTime(lvItem.trendItem.DateTimeSecondCandle).Date
                            &&
                            Convert.ToDateTime(item.DateOfYear).Date <=
                            DateTime.Now.Date
                            )
                        {

                            if (tmpTime <= Convert.ToDateTime(item.DateOfYear).Date)
                            {
                                if ((classcode == "SPBFUT" && tmpTamlate.StartTimeForts != new TimeSpan(0, 0, 0) &&
                                     tmpTamlate.EndTimeForts != new TimeSpan(0, 0, 0)) ||
                                    (classcode != "SPBFUT" && tmpTamlate.StartTimeMmvb != new TimeSpan(0, 0, 0) &&
                                     tmpTamlate.EndTimeMmvb != new TimeSpan(0, 0, 0)))
                                {
                                    if (tmpTime < Convert.ToDateTime(item.DateOfYear).Date)
                                        if (lvItem.trendItem.Interval == cfg.day)
                                        {
                                            tmpTime.AddDays(1);
                                            countCandle++;
                                        }
                                    if (lvItem.trendItem.Interval == cfg.week)
                                    {
                                        if (tmpTime.AddDays(6).Date <= Convert.ToDateTime(item.DateOfYear).Date)
                                        {
                                            tmpTime = tmpTime.AddDays(6);
                                            countCandle++;
                                        }

                                    }
                                    if (lvItem.trendItem.Interval == cfg.month)
                                    {
                                        if (tmpTime.AddMonths(1).Date <= Convert.ToDateTime(item.DateOfYear).Date)
                                        {
                                            tmpTime.AddMonths(1);
                                            countCandle++;
                                        }
                                    }
                                }
                            }
                            //else
                            //    break;
                        }
                    }
                }
                return lvItem.trendItem.PriceSecondCandle + lvItem.trendItem.StepTrendCandle * countCandle;
            }


            return 0;
        }

        /// <summary>
        /// Определяем количество свечей между указанными датами и заданным периодом
        /// </summary>
        /// <param name="lvItem"></param>
        /// <returns></returns>
        public int GetCountCandleBetweenDate(LevelItem lvItem, ref double stepTrend)
        {
            int countCandle = 0;
            string classcode = MainWindow.StaticLevel._dataProvider.GetClasscode(lvItem.Instrument);
            if (lvItem.trendItem.Interval != cfg.day && lvItem.trendItem.Interval != cfg.week &&
                lvItem.trendItem.Interval != cfg.month)

            #region Работа с интервалами до дня

            {
                TimeSpan interval = GeTimeSpan(lvItem);
                TimeSpan tmpTime = lvItem.trendItem.DateTimeFirstCandle.TimeOfDay;
                foreach (var item in MainWindow.StaticLevel._dataProvider.CalendarItemList)
                {
                    if (Convert.ToDateTime(item.DateOfYear).Date >=
                        Convert.ToDateTime(lvItem.trendItem.DateTimeFirstCandle).Date
                        &&
                        Convert.ToDateTime(item.DateOfYear).Date <=
                        Convert.ToDateTime(lvItem.trendItem.DateTimeSecondCandle).Date
                        )
                    {
                        if (Convert.ToDateTime(item.DateOfYear).Date !=
                            Convert.ToDateTime(lvItem.trendItem.DateTimeFirstCandle).Date &&
                            Convert.ToDateTime(item.DateOfYear).Date >
                            Convert.ToDateTime(lvItem.trendItem.DateTimeFirstCandle).Date)
                        {
                            if (classcode == "SPBFUT")
                                tmpTime = GettamplateTime(item.ShablonTime).StartTimeForts;
                            else
                                tmpTime = GettamplateTime(item.ShablonTime).StartTimeMmvb;
                        }


                        for (int i = 0; i < 1000; i++)
                        {
                            //добавление интервалов в день и время последней точки
                            if (Convert.ToDateTime(item.DateOfYear).Date ==
                                Convert.ToDateTime(lvItem.trendItem.DateTimeSecondCandle).Date)
                                if (tmpTime < lvItem.trendItem.DateTimeSecondCandle.TimeOfDay)
                                {
                                    tmpTime = tmpTime + interval;
                                    countCandle++;
                                }
                                else
                                {
                                    break;
                                }
                            if (Convert.ToDateTime(item.DateOfYear).Date !=
                                Convert.ToDateTime(lvItem.trendItem.DateTimeSecondCandle).Date)
                            {
                                var tmpTamlate = GettamplateTime(item.ShablonTime);
                                if (classcode == "SPBFUT")
                                {

                                    //Обработка клирингов
                                    if (tmpTime + interval <= tmpTamlate.EndTimeForts &&
                                        tmpTime + interval > tmpTamlate.StartTimeForts)
                                    {
                                        if (tmpTime + interval <= tmpTamlate.StartDayKliring ||
                                            (tmpTime + interval >= tmpTamlate.EndDayKliring &&
                                             tmpTime <= tmpTamlate.StartEveningKliring) ||
                                            tmpTime + interval > tmpTamlate.EndEveningKliring)
                                        {
                                            countCandle++;
                                            tmpTime = tmpTime + interval;
                                        }
                                        else
                                        {
                                            tmpTime = tmpTime + interval;
                                        }
                                    }

                                }
                                if (classcode != "SPBFUT")
                                    if (tmpTime <= tmpTamlate.EndTimeMmvb &&
                                        tmpTime + interval > tmpTamlate.StartTimeMmvb)
                                    {
                                        countCandle++;
                                        tmpTime = tmpTime + interval;
                                    }
                                    else
                                    {
                                        break;
                                    }
                            }

                        }
                        if (Convert.ToDateTime(item.DateOfYear).Date ==
                            Convert.ToDateTime(lvItem.trendItem.DateTimeSecondCandle).Date)
                            break;

                    }
                }
            }
            #endregion

            else
            {

                DateTime tmpTime = lvItem.trendItem.DateTimeFirstCandle;
                foreach (var item in MainWindow.StaticLevel._dataProvider.CalendarItemList)
                {
                    var tmpTamlate = GettamplateTime(item.ShablonTime);
                    if (Convert.ToDateTime(item.DateOfYear).Date >=
                        Convert.ToDateTime(lvItem.trendItem.DateTimeFirstCandle).Date
                        &&
                        Convert.ToDateTime(item.DateOfYear).Date <=
                        Convert.ToDateTime(lvItem.trendItem.DateTimeSecondCandle).Date
                        )
                    {

                        if (tmpTime <= Convert.ToDateTime(item.DateOfYear).Date)
                        {
                            if ((classcode == "SPBFUT" && tmpTamlate.StartTimeForts != new TimeSpan(0, 0, 0) &&
                                 tmpTamlate.EndTimeForts != new TimeSpan(0, 0, 0)) ||
                                (classcode != "SPBFUT" && tmpTamlate.StartTimeMmvb != new TimeSpan(0, 0, 0) &&
                                 tmpTamlate.EndTimeMmvb != new TimeSpan(0, 0, 0)))
                            {
                                if (tmpTime < Convert.ToDateTime(item.DateOfYear).Date)
                                    if (lvItem.trendItem.Interval == cfg.day)
                                    {
                                        tmpTime.AddDays(1);
                                        countCandle++;
                                    }
                                if (lvItem.trendItem.Interval == cfg.week)
                                {
                                    if (tmpTime.AddDays(6).Date <= Convert.ToDateTime(item.DateOfYear).Date)
                                    {
                                        tmpTime = tmpTime.AddDays(6);
                                        countCandle++;
                                    }

                                }
                                if (lvItem.trendItem.Interval == cfg.month)
                                {
                                    if (tmpTime.AddMonths(1).Date <= Convert.ToDateTime(item.DateOfYear).Date)
                                    {
                                        tmpTime.AddMonths(1);
                                        countCandle++;
                                    }
                                }
                            }
                        }
                        //else
                        //    break;
                    }
                }
            }


            stepTrend = (lvItem.trendItem.PriceSecondCandle - lvItem.trendItem.PriceFirstCandle) / countCandle;

            return countCandle;
        }

        public TamplateTimeWorkingExhange GettamplateTime(string Name)
        {
            foreach (var item in MainWindow.StaticLevel._dataProvider.TamplateTimeWorkingList)
            {
                if (item.Name == Name)
                    return item;
            }

            return null;
        }

        public TimeSpan GeTimeSpan(LevelItem lv)
        {
            switch (lv.trendItem.Interval)
            {
                case "1 мин":
                    return new TimeSpan(0, 1, 0);
                case "2 мин":
                    return new TimeSpan(0, 2, 0);
                case "3 мин":
                    return new TimeSpan(0, 3, 0);
                case "4 мин":
                    return new TimeSpan(0, 4, 0);
                case "5 мин":
                    return new TimeSpan(0, 5, 0);
                case "6 мин":
                    return new TimeSpan(0, 6, 0);
                case "10 мин":
                    return new TimeSpan(0, 10, 0);
                case "15 мин":
                    return new TimeSpan(0, 15, 0);
                case "20 мин":
                    return new TimeSpan(0, 20, 0);
                case "30 мин":
                    return new TimeSpan(0, 30, 0);
                case "1 час":
                    return new TimeSpan(1, 0, 0);
                case "2 часа":
                    return new TimeSpan(2, 0, 0);
                case "4 часа":
                    return new TimeSpan(4, 0, 0);
                default:
                    return new TimeSpan(0, 0, 0);
            }
        }
    }
}
